import { http } from "@/utils/http";

/**
 * 文章标签管理 API 接口
 *
 * 根据 TAG-MANAGEMENT-API.md v1.0.0 实现
 * 支持完整的标签CRUD操作、批量操作、统计分析等功能
 */

// ==================== 类型定义 ====================

/** API响应基础类型 */
export interface ApiResponse<T = any> {
  code: number;
  message: string;
  data: T;
}

/** 分页响应类型 */
export interface PageResult<T> {
  records: T[];
  total: number;
  size: number;
  current: number;
  pages: number;
}

/** 标签状态枚举 */
export enum TagStatus {
  /** 禁用 */
  DISABLED = 0,
  /** 启用 */
  ENABLED = 1
}

/** 使用频率等级枚举 */
export enum UsageLevel {
  /** 未使用 */
  UNUSED = 0,
  /** 低频 */
  LOW = 1,
  /** 中频 */
  MEDIUM = 2,
  /** 高频 */
  HIGH = 3
}

/** 批量操作类型枚举 */
export enum BatchOperationType {
  /** 启用 */
  ENABLE = "ENABLE",
  /** 禁用 */
  DISABLE = "DISABLE",
  /** 删除 */
  DELETE = "DELETE",
  /** 更新颜色 */
  UPDATE_COLOR = "UPDATE_COLOR",
  /** 重置使用次数 */
  RESET_USE_COUNT = "RESET_USE_COUNT",
  /** 合并标签 */
  MERGE_TAGS = "MERGE_TAGS"
}

/** 标签信息 */
export interface TagInfo {
  /** 标签ID */
  id: number;
  /** 标签名称 */
  name: string;
  /** 标签颜色 */
  color: string;
  /** 使用次数 */
  useCount: number;
  /** 状态：0-禁用，1-启用 */
  status: number;
  /** 使用频率等级：0-未使用，1-低频，2-中频，3-高频 */
  usageLevel: number;
  /** 关联文章总数（仅当includeUsageStats=true时返回） */
  articleCount?: number;
  /** 已发布文章数（仅当includeUsageStats=true时返回） */
  publishedArticleCount?: number;
  /** 草稿文章数（仅当includeUsageStats=true时返回） */
  draftArticleCount?: number;
  /** 最近使用时间（仅当includeUsageStats=true时返回） */
  lastUsedTime?: string;
  /** 创建时间 */
  createTime: string;
  /** 更新时间 */
  updateTime: string;
}

/** 标签查询参数 */
export interface TagListQuery {
  /** 当前页 */
  current?: number;
  /** 页大小 */
  size?: number;
  /** 标签名称 */
  name?: string;
  /** 状态 */
  status?: number;
  /** 颜色 */
  color?: string;
  /** 最小使用次数 */
  minUseCount?: number;
  /** 最大使用次数 */
  maxUseCount?: number;
  /** 使用频率等级 */
  usageLevel?: number;
  /** 开始时间 */
  startTime?: string;
  /** 结束时间 */
  endTime?: string;
  /** 排序字段 */
  sortField?: string;
  /** 排序方式 */
  sortOrder?: string;
  /** 是否包含使用统计 */
  includeUsageStats?: boolean;
}

/** 创建标签参数 */
export interface CreateTagRequest {
  /** 标签名称 */
  name: string;
  /** 标签颜色 */
  color?: string;
  /** 状态 */
  status: number;
}

/** 更新标签参数 */
export interface UpdateTagRequest {
  /** 标签ID */
  id: number;
  /** 标签名称 */
  name: string;
  /** 标签颜色 */
  color?: string;
  /** 状态 */
  status: number;
}

/** 批量操作参数 */
export interface BatchOperationParams {
  /** 标签ID列表 */
  tagIds: number[];
  /** 操作类型：ENABLE/DISABLE/DELETE/UPDATE_COLOR/RESET_USE_COUNT/MERGE_TAGS */
  operation: string;
  /** 目标状态（用于启用/禁用操作） */
  targetStatus?: number;
  /** 目标颜色（用于更新颜色操作） */
  targetColor?: string;
  /** 操作原因 */
  reason?: string;
  /** 是否强制删除 */
  forceDelete?: boolean;
}

/** 批量操作响应 */
export interface BatchOperationResult {
  /** 操作类型 */
  operation: string;
  /** 成功数量 */
  successCount: number;
  /** 失败数量 */
  failCount: number;
  /** 总数量 */
  totalCount: number;
  /** 详细信息 */
  details: string;
}

/** 标签名称检查结果 */
export interface TagNameCheckResult {
  /** 是否可用 */
  available: boolean;
  /** 检查信息 */
  message: string;
}

/** 清理结果 */
export interface CleanupResult {
  /** 清理数量 */
  cleanedCount: number;
  /** 结果信息 */
  message: string;
}

/** 同步结果 */
export interface SyncResult {
  /** 同步数量 */
  syncedCount: number;
  /** 结果信息 */
  message: string;
}

/** 合并标签参数 */
export interface MergeTagsParams {
  /** 源标签ID列表（将被合并的标签） */
  sourceTagIds: number[];
  /** 目标标签ID（合并到的标签） */
  targetTagId: number;
  /** 合并原因 */
  reason?: string;
}

/** 标签统计信息 */
export interface TagStatistics {
  /** 总标签数 */
  totalTags: number;
  /** 启用标签数 */
  enabledTags: number;
  /** 禁用标签数 */
  disabledTags: number;
  /** 已使用标签数 */
  usedTags: number;
  /** 未使用标签数 */
  unusedTags: number;
  /** 热门标签数 */
  popularTags: number;
  /** 平均使用次数 */
  avgUseCount: number;
  /** 最大使用次数 */
  maxUseCount: number;
  /** 总使用次数 */
  totalUseCount: number;
}

/** 标签状态分布 */
export interface TagStatusDistribution {
  /** 状态：0-禁用，1-启用 */
  status: number;
  /** 数量 */
  count: number;
  /** 状态名称 */
  statusName: string;
}

/** 标签使用频率分布 */
export interface TagUsageDistribution {
  /** 使用频率等级 */
  usageLevel: string;
  /** 数量 */
  count: number;
}

/** 标签颜色分布 */
export interface TagColorDistribution {
  /** 颜色 */
  color: string;
  /** 数量 */
  count: number;
}

/** 标签趋势统计 */
export interface TagTrendStatistics {
  /** 月份 */
  month: string;
  /** 创建标签数 */
  createdCount: number;
  /** 启用标签数 */
  enabledCount: number;
}

// ==================== API 接口函数 ====================

/** 分页查询标签列表 */
export const getTagListApi = (params: TagListQuery) => {
  return http.request<ApiResponse<PageResult<TagInfo>>>(
    "get",
    "/admin/tags/list",
    { params }
  );
};

/** 获取标签详情 */
export const getTagDetailApi = (tagId: number) => {
  return http.request<ApiResponse<TagInfo>>("get", `/admin/tags/${tagId}`);
};

/** 获取启用的标签列表 */
export const getEnabledTagsApi = () => {
  return http.request<ApiResponse<TagInfo[]>>("get", "/admin/tags/enabled");
};

/** 获取热门标签列表 */
export const getPopularTagsApi = (limit: number = 10) => {
  return http.request<ApiResponse<TagInfo[]>>("get", "/admin/tags/popular", {
    params: { limit }
  });
};

/** 获取最近创建的标签 */
export const getRecentTagsApi = (limit: number = 10) => {
  return http.request<ApiResponse<TagInfo[]>>("get", "/admin/tags/recent", {
    params: { limit }
  });
};

/** 创建标签 */
export const createTagApi = (data: CreateTagRequest) => {
  return http.request<ApiResponse>("post", "/admin/tags/create", { data });
};

/** 更新标签 */
export const updateTagApi = (data: UpdateTagRequest) => {
  return http.request<ApiResponse>("put", "/admin/tags/update", { data });
};

/** 删除标签 */
export const deleteTagApi = (tagId: number, force: boolean = false) => {
  return http.request<ApiResponse>("delete", `/admin/tags/${tagId}`, {
    params: { force }
  });
};

/** 启用标签 */
export const enableTagApi = (tagId: number) => {
  return http.request<ApiResponse>("post", `/admin/tags/${tagId}/enable`);
};

/** 禁用标签 */
export const disableTagApi = (tagId: number) => {
  return http.request<ApiResponse>("post", `/admin/tags/${tagId}/disable`);
};

/** 更新标签颜色 */
export const updateTagColorApi = (tagId: number, color: string) => {
  return http.request<ApiResponse>("post", `/admin/tags/${tagId}/color`, {
    params: { color }
  });
};

/** 重置标签使用次数 */
export const resetTagCountApi = (tagId: number) => {
  return http.request<ApiResponse>("post", `/admin/tags/${tagId}/reset-count`);
};

/** 批量操作标签 */
export const batchOperateTagsApi = (params: BatchOperationParams) => {
  return http.request<ApiResponse<BatchOperationResult>>(
    "post",
    "/admin/tags/batch",
    { data: params }
  );
};

/** 搜索标签（自动完成） */
export const searchTagsApi = (keyword: string, limit: number = 10) => {
  return http.request<ApiResponse<TagInfo[]>>("get", "/admin/tags/search", {
    params: { keyword, limit }
  });
};

/** 获取相似标签 */
export const getSimilarTagsApi = (tagName: string, limit: number = 5) => {
  return http.request<ApiResponse<TagInfo[]>>("get", "/admin/tags/similar", {
    params: { tagName, limit }
  });
};

/** 合并标签 */
export const mergeTagsApi = (params: MergeTagsParams) => {
  return http.request<ApiResponse>("post", "/admin/tags/merge", {
    data: params
  });
};

/** 检查标签名称是否可用 */
export const checkTagNameApi = (name: string, excludeId?: number) => {
  const params: any = { name };
  if (excludeId) {
    params.excludeId = excludeId;
  }
  return http.request<ApiResponse<TagNameCheckResult>>(
    "get",
    "/admin/tags/check-name",
    { params }
  );
};

/** 获取未使用的标签列表 */
export const getUnusedTagsApi = () => {
  return http.request<ApiResponse<TagInfo[]>>("get", "/admin/tags/unused");
};

/** 清理未使用的标签 */
export const cleanupUnusedTagsApi = (daysBefore: number = 30) => {
  return http.request<ApiResponse<CleanupResult>>(
    "post",
    "/admin/tags/cleanup",
    { params: { daysBefore } }
  );
};

/** 同步标签使用次数 */
export const syncTagCountsApi = () => {
  return http.request<ApiResponse<SyncResult>>(
    "post",
    "/admin/tags/sync-counts"
  );
};

/** 获取标签统计信息 */
export const getTagStatisticsApi = () => {
  return http.request<ApiResponse<TagStatistics>>(
    "get",
    "/admin/tags/statistics"
  );
};

/** 获取标签状态分布 */
export const getTagStatusDistributionApi = () => {
  return http.request<ApiResponse<TagStatusDistribution[]>>(
    "get",
    "/admin/tags/status-distribution"
  );
};

/** 获取标签使用频率分布 */
export const getTagUsageDistributionApi = () => {
  return http.request<ApiResponse<TagUsageDistribution[]>>(
    "get",
    "/admin/tags/usage-distribution"
  );
};

/** 获取标签颜色分布统计 */
export const getTagColorDistributionApi = () => {
  return http.request<ApiResponse<TagColorDistribution[]>>(
    "get",
    "/admin/tags/color-distribution"
  );
};

/** 获取标签趋势统计 */
export const getTagTrendStatisticsApi = (months: number = 6) => {
  return http.request<ApiResponse<TagTrendStatistics[]>>(
    "get",
    "/admin/tags/trend-statistics",
    { params: { months } }
  );
};

// ==================== 工具类 ====================

export class TagManagementUtils {
  /** 获取标签状态文本 */
  static getStatusText(status: number): string {
    const statusMap: Record<number, string> = {
      0: "禁用",
      1: "启用"
    };
    return statusMap[status] || "未知状态";
  }

  /** 获取状态标签类型 */
  static getStatusTagType(
    status: number
  ): "success" | "info" | "warning" | "danger" | "primary" {
    const typeMap: Record<
      number,
      "success" | "info" | "warning" | "danger" | "primary"
    > = {
      0: "danger",
      1: "success"
    };
    return typeMap[status] || "info";
  }

  /** 获取使用频率等级文本 */
  static getUsageLevelText(level: number): string {
    const levelMap: Record<number, string> = {
      0: "未使用",
      1: "低频",
      2: "中频",
      3: "高频"
    };
    return levelMap[level] || "未知";
  }

  /** 获取使用频率等级颜色 */
  static getUsageLevelColor(level: number): string {
    const colorMap: Record<number, string> = {
      0: "#909399",
      1: "#67c23a",
      2: "#e6a23c",
      3: "#f56c6c"
    };
    return colorMap[level] || "#909399";
  }

  /** 根据使用次数计算使用频率等级 */
  static calculateUsageLevel(useCount: number): number {
    if (useCount === 0) return 0; // 未使用
    if (useCount <= 5) return 1; // 低频
    if (useCount <= 20) return 2; // 中频
    return 3; // 高频
  }

  /** 获取批量操作类型文本 */
  static getBatchOperationText(type: string): string {
    const textMap: Record<string, string> = {
      ENABLE: "启用",
      DISABLE: "禁用",
      DELETE: "删除",
      UPDATE_COLOR: "更新颜色",
      RESET_USE_COUNT: "重置使用次数",
      MERGE_TAGS: "合并标签"
    };
    return textMap[type] || "未知操作";
  }

  /** 验证标签名称 */
  static validateTagName(name: string): { valid: boolean; message?: string } {
    if (!name || name.trim().length === 0) {
      return { valid: false, message: "标签名称不能为空" };
    }

    if (name.length > 50) {
      return { valid: false, message: "标签名称不能超过50个字符" };
    }

    // 检查特殊字符
    const invalidChars = /[<>"'&]/;
    if (invalidChars.test(name)) {
      return { valid: false, message: "标签名称不能包含特殊字符" };
    }

    return { valid: true };
  }

  /** 验证颜色格式 */
  static validateColor(color: string): { valid: boolean; message?: string } {
    if (!color) {
      return { valid: true }; // 颜色可以为空，系统会自动生成
    }

    // 检查十六进制颜色格式
    const colorRegex = /^#[0-9A-Fa-f]{6}$/;
    if (!colorRegex.test(color)) {
      return {
        valid: false,
        message: "颜色格式不正确，请使用十六进制格式（如：#FF5722）"
      };
    }

    return { valid: true };
  }

  /** 生成随机颜色 */
  static generateRandomColor(): string {
    const colors = [
      "#f56c6c",
      "#e6a23c",
      "#67c23a",
      "#1890ff",
      "#722ed1",
      "#eb2f96",
      "#fa541c",
      "#fadb14",
      "#52c41a",
      "#13c2c2",
      "#2f54eb",
      "#722ed1",
      "#fa8c16",
      "#a0d911",
      "#36cfc9"
    ];
    return colors[Math.floor(Math.random() * colors.length)];
  }

  /** 根据标签名称生成颜色 */
  static generateColorByName(name: string): string {
    let hash = 0;
    for (let i = 0; i < name.length; i++) {
      hash = name.charCodeAt(i) + ((hash << 5) - hash);
    }

    const colors = [
      "#f56c6c",
      "#e6a23c",
      "#67c23a",
      "#1890ff",
      "#722ed1",
      "#eb2f96",
      "#fa541c",
      "#fadb14",
      "#52c41a",
      "#13c2c2",
      "#2f54eb",
      "#722ed1",
      "#fa8c16",
      "#a0d911",
      "#36cfc9"
    ];

    return colors[Math.abs(hash) % colors.length];
  }

  /** 格式化使用次数显示 */
  static formatUseCount(count: number): string {
    if (count === 0) return "0";
    if (count < 1000) return count.toString();
    if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
    return `${(count / 10000).toFixed(1)}w`;
  }

  /** 检查是否可以执行操作 */
  static canPerformOperation(status: number, operation: string): boolean {
    const operationMap: Record<number, string[]> = {
      0: ["ENABLE", "DELETE"], // 禁用的标签可以启用和删除
      1: ["DISABLE", "DELETE"] // 启用的标签可以禁用和删除
    };

    return operationMap[status]?.includes(operation) || false;
  }

  /** 转换布尔值 */
  static toBool(value: any): boolean {
    if (typeof value === "boolean") return value;
    if (typeof value === "number") return value === 1;
    if (typeof value === "string")
      return value === "1" || value.toLowerCase() === "true";
    return false;
  }

  /** 清理标签名称 */
  static cleanTagName(name: string): string {
    return name.trim().replace(/\s+/g, " ");
  }

  /** 计算标签热度 */
  static calculateTagHeat(useCount: number, maxUseCount: number): number {
    if (maxUseCount === 0) return 0;
    return Math.round((useCount / maxUseCount) * 100);
  }

  /** 格式化统计数据字段名 */
  static formatStatisticsData(data: any): TagStatistics {
    return {
      totalTags: data.totalTags || data.total_tags || 0,
      enabledTags: data.enabledTags || data.enabled_tags || 0,
      disabledTags: data.disabledTags || data.disabled_tags || 0,
      usedTags: data.usedTags || data.used_tags || 0,
      unusedTags: data.unusedTags || data.unused_tags || 0,
      popularTags: data.popularTags || data.popular_tags || 0,
      avgUseCount: data.avgUseCount || data.avg_use_count || 0,
      maxUseCount: data.maxUseCount || data.max_use_count || 0,
      totalUseCount: data.totalUseCount || data.total_use_count || 0
    };
  }

  /** 格式化状态分布数据 */
  static formatStatusDistribution(data: any[]): TagStatusDistribution[] {
    return data.map(item => ({
      status: item.status,
      count: item.count,
      statusName:
        item.statusName || item.status_name || this.getStatusText(item.status)
    }));
  }

  /** 格式化使用频率分布数据 */
  static formatUsageDistribution(data: any[]): TagUsageDistribution[] {
    return data.map(item => ({
      usageLevel: item.usageLevel || item.usage_level,
      count: item.count
    }));
  }

  /** 格式化趋势统计数据 */
  static formatTrendStatistics(data: any[]): TagTrendStatistics[] {
    return data.map(item => ({
      month: item.month,
      createdCount: item.createdCount || item.new_tags || 0,
      enabledCount: item.enabledCount || item.used_tags || 0
    }));
  }
}
